{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><img src=\"TChem_Logo_Small.jpg\" alt=\"Drawing\" style=\"width: 400px;\"/></center>\n",
    "\n",
    "# Homogeneous Gas Reactor (Ignition Zero D problem)\n",
    "\n",
    "***Energy equation***\n",
    "$$\n",
    "\\frac{dT}{dt}= -\\frac{1}{\\rho c_p}\\sum_{k=1}^{N_{spec}}\\dot{\\omega_{k}} W_k h_k = S_T\n",
    "$$\n",
    "***Species equation***\n",
    "$$\n",
    "\\frac{dY_k}{dt}=\\frac{1}{\\rho}\\dot{\\omega_{k}}W_k=S_{Y_k},\\,\\,\\,k=1\\ldots N_{spec}\n",
    "$$\n",
    "\n",
    "## Environment Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "TChem_install_directory ='where/TChem/is/installed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append(TChem_install_directory+'/lib')\n",
    "import pytchem\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(TChem_install_directory+'/example/runs/scripts/')\n",
    "import pmixSample\n",
    "import helper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-simulation\n",
    "* Set variables; temperature and stoichiometric ratio (fuel/air).\n",
    "* Convert from stoichiometric ratio to mass fraction of CH4, O2, N2 and AR.\n",
    "* Create samples spaning over the variable ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pressure, Temperature, phi(stoichiometric ratio)\n",
    "one_atm = 101325 # [Pa]\n",
    "TempMax = 1300   # Maximum temperature [K]\n",
    "TempMin = 1000   # Minimum temperature [K]\n",
    "\n",
    "PressureMax = 1*one_atm; # [Pa]\n",
    "PressureMin = 1*one_atm; # [Pa]\n",
    "\n",
    "phiMax = 3.0; # Maximum equivalence ratio [-]\n",
    "phiMin = 0.8; # Minimum equivalence ratio [-]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "Npp = 1\n",
    "Npt = 10 \n",
    "Npphi = 10\n",
    "N = Npp*Npt*Npphi\n",
    "\n",
    "pressure    = [PressureMin] #\n",
    "temperature = np.linspace(TempMin, TempMax, Npt)\n",
    "eqratio     = np.linspace(phiMin, phiMax, Npphi)\n",
    "p, temp, phi = np.meshgrid(pressure, temperature,eqratio)\n",
    "p    = p.reshape(np.size(p))       #flatten()\n",
    "temp = temp.reshape(np.size(temp)) #flatten()\n",
    "phi  = phi.reshape(np.size(phi))   #flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Nvar = 6\n",
    "sample = np.zeros([N,Nvar])\n",
    "fuel =\"CH4\"\n",
    "nC=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(N):\n",
    "    sample[i,0] = temp[i]\n",
    "    sample[i,1] = p[i]\n",
    "    Yp_fuel, Yr_o2, Yr_n2, Yr_ar = pmixSample.getMassFraction(nC,phi[i])\n",
    "    sample[i,2] = Yp_fuel\n",
    "    sample[i,3] = Yr_o2\n",
    "    sample[i,4] = Yr_n2 \n",
    "    sample[i,5] = Yr_ar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TChem Simulation\n",
    "\n",
    "### Initialize TChem Driver Object\n",
    "\n",
    "* Initialization of Kokkos.\n",
    "* Create a TChem driver object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pytchem.initialize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tchem = pytchem.TChemDriver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Get help from TChem driver object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on TChemDriver in module pytchem object:\n",
      "\n",
      "class TChemDriver(pybind11_builtins.pybind11_object)\n",
      " |  A class to manage data movement between numpy to kokkos views in TChem::Driver object\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      TChemDriver\n",
      " |      pybind11_builtins.pybind11_object\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(...)\n",
      " |      __init__(self: pytchem.TChemDriver) -> None\n",
      " |  \n",
      " |  cloneGasKineticModel(...)\n",
      " |      cloneGasKineticModel(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Internally create clones of the kinetic model\n",
      " |  \n",
      " |  computeGasEnthapyMass(...)\n",
      " |      computeGasEnthapyMass(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Compute enthalpy mass and mixture enthalpy\n",
      " |  \n",
      " |  computeGasNetProductionRatePerMass(...)\n",
      " |      computeGasNetProductionRatePerMass(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Compute net production rate\n",
      " |  \n",
      " |  computeGasReactionRateConstants(...)\n",
      " |      computeGasReactionRateConstants(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Compute forward/reverse rate constant\n",
      " |  \n",
      " |  computeJacobianHomogeneousGasReactor(...)\n",
      " |      computeJacobianHomogeneousGasReactor(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Compute Jacobian matrix for homogeneous gas reactor\n",
      " |  \n",
      " |  computeRHS_HomogeneousGasReactor(...)\n",
      " |      computeRHS_HomogeneousGasReactor(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Compute RHS for homogeneous gas reactor\n",
      " |  \n",
      " |  computeTimeAdvanceHomogeneousGasReactor(...)\n",
      " |      computeTimeAdvanceHomogeneousGasReactor(self: pytchem.TChemDriver) -> float\n",
      " |      \n",
      " |      Compute Time Advance for a Homogeneous-Gas Reactor\n",
      " |  \n",
      " |  createAllViews(...)\n",
      " |      createAllViews(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate all necessary workspace for this driver\n",
      " |  \n",
      " |  createGasEnthapyMass(...)\n",
      " |      createGasEnthapyMass(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for enthalpy mass  (# samples, # species )\n",
      " |  \n",
      " |  createGasKineticModel(...)\n",
      " |      createGasKineticModel(self: pytchem.TChemDriver, chemkin_input: str, thermo_data: str) -> None\n",
      " |      \n",
      " |      Create a kinetic model from CHEMKIN input files\n",
      " |  \n",
      " |  createGasKineticModelConstData(...)\n",
      " |      createGasKineticModelConstData(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Internally construct const object of the kinetic model and load them to device\n",
      " |  \n",
      " |  createGasKineticModelConstDataWithArreniusForwardParameters(...)\n",
      " |      createGasKineticModelConstDataWithArreniusForwardParameters(self: pytchem.TChemDriver, reac_indices: numpy.ndarray[numpy.int32], factors: numpy.ndarray[numpy.float64]) -> None\n",
      " |      \n",
      " |      Creates clones of the kinetic model; modifies the Arrhenius forward parameters of the clones;and creates a const object of the kinetics models.factors is a 3d array of size: number of samples, number of reactions to be modified, and 3 kinetic parameters. kinetic parameters: pre exponential (0), temperature coefficient(1), and activation energy(2)\n",
      " |  \n",
      " |  createGasNetProductionRatePerMass(...)\n",
      " |      createGasNetProductionRatePerMass(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for net production rate per mass (# samples, # species)\n",
      " |  \n",
      " |  createGasReactionRateConstants(...)\n",
      " |      createGasReactionRateConstants(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for forward/reverse rate constants  (# samples, # reactions )\n",
      " |  \n",
      " |  createJacobianHomogeneousGasReactor(...)\n",
      " |      createJacobianHomogeneousGasReactor(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for homogeneous-gas-reactor Jacobian  (# samples, # species + 1  # species + 1)\n",
      " |  \n",
      " |  createRHS_HomogeneousGasReactor(...)\n",
      " |      createRHS_HomogeneousGasReactor(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for homogeneous-gas-reactor RHS  (# samples, # species + 1 )\n",
      " |  \n",
      " |  createStateVector(...)\n",
      " |      createStateVector(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Allocate memory for state vector (# samples, state vector length)\n",
      " |  \n",
      " |  freeAllViews(...)\n",
      " |      freeAllViews(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Free all necessary workspace for this driver\n",
      " |  \n",
      " |  getGasArrheniusForwardParameter(...)\n",
      " |      getGasArrheniusForwardParameter(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getGasArrheniusForwardParameter(self: pytchem.TChemDriver, reac_indices: numpy.ndarray[numpy.int32], param_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive pre exponential for reactions listed by reaction_indices\n",
      " |      \n",
      " |      2. getGasArrheniusForwardParameter(self: pytchem.TChemDriver, imodel: int, reac_indices: numpy.ndarray[numpy.int32], param_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive pre exponential for reactions listed by reaction_indices\n",
      " |  \n",
      " |  getGasEnthapyMass(...)\n",
      " |      getGasEnthapyMass(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive enthalpy mass per species for all samples\n",
      " |  \n",
      " |  getGasEnthapyMixMass(...)\n",
      " |      getGasEnthapyMixMass(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve mixture enthalpy for all samples\n",
      " |  \n",
      " |  getGasForwardReactionRateConstants(...)\n",
      " |      getGasForwardReactionRateConstants(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getGasForwardReactionRateConstants(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive forward rate constants for a single sample\n",
      " |      \n",
      " |      2. getGasForwardReactionRateConstants(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve forward rate constants  for all samples\n",
      " |  \n",
      " |  getGasNetProductionRatePerMass(...)\n",
      " |      getGasNetProductionRatePerMass(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getGasNetProductionRatePerMass(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive net production rate for a single sample\n",
      " |      \n",
      " |      2. getGasNetProductionRatePerMass(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve net production rate for all samples\n",
      " |  \n",
      " |  getGasReverseReactionRateConstants(...)\n",
      " |      getGasReverseReactionRateConstants(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getGasReverseReactionRateConstants(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive reverse rate constants for a single sample\n",
      " |      \n",
      " |      2. getGasReverseReactionRateConstants(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve reverse rate constants  for all samples\n",
      " |  \n",
      " |  getJacobianHomogeneousGasReactor(...)\n",
      " |      getJacobianHomogeneousGasReactor(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive homogeneous-gas-reactor Jacobian for a single sample\n",
      " |  \n",
      " |  getLengthOfStateVector(...)\n",
      " |      getLengthOfStateVector(self: pytchem.TChemDriver) -> int\n",
      " |      \n",
      " |      Get the size of state vector i.e., rho, P, T, Y_{0-Nspec-1}\n",
      " |  \n",
      " |  getNumberOfReactions(...)\n",
      " |      getNumberOfReactions(self: pytchem.TChemDriver) -> int\n",
      " |      \n",
      " |      Get the number of reactions registered in the kinetic model\n",
      " |  \n",
      " |  getNumberOfSamples(...)\n",
      " |      getNumberOfSamples(self: pytchem.TChemDriver) -> int\n",
      " |      \n",
      " |      Get the number of samples which is currently used in the driver\n",
      " |  \n",
      " |  getNumberOfSpecies(...)\n",
      " |      getNumberOfSpecies(self: pytchem.TChemDriver) -> int\n",
      " |      \n",
      " |      Get the number of species registered in the kinetic model\n",
      " |  \n",
      " |  getRHS_HomogeneousGasReactor(...)\n",
      " |      getRHS_HomogeneousGasReactor(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getRHS_HomogeneousGasReactor(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrive homogeneous-gas-reactor RHS for a single sample\n",
      " |      \n",
      " |      2. getRHS_HomogeneousGasReactor(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve homogeneous-gas-reactor RHS_ for all samples\n",
      " |  \n",
      " |  getSpeciesIndex(...)\n",
      " |      getSpeciesIndex(self: pytchem.TChemDriver, species_name: str) -> int\n",
      " |      \n",
      " |      Get species index\n",
      " |  \n",
      " |  getStateVariableIndex(...)\n",
      " |      getStateVariableIndex(self: pytchem.TChemDriver, var_name: str) -> int\n",
      " |      \n",
      " |      Get state variable index\n",
      " |  \n",
      " |  getStateVector(...)\n",
      " |      getStateVector(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. getStateVector(self: pytchem.TChemDriver, sample_index: int) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve state vector for a single sample\n",
      " |      \n",
      " |      2. getStateVector(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve state vector for all samples\n",
      " |  \n",
      " |  getTimeStep(...)\n",
      " |      getTimeStep(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve time line of all samples\n",
      " |  \n",
      " |  getTimeStepSize(...)\n",
      " |      getTimeStepSize(self: pytchem.TChemDriver) -> numpy.ndarray[numpy.float64]\n",
      " |      \n",
      " |      Retrieve time step sizes of all samples\n",
      " |  \n",
      " |  modifyGasArrheniusForwardParameters(...)\n",
      " |      modifyGasArrheniusForwardParameters(self: pytchem.TChemDriver, reac_indices: numpy.ndarray[numpy.int32], factors: numpy.ndarray[numpy.float64]) -> None\n",
      " |      \n",
      " |      Modify the cloned kinetic models Arrhenius parameters\n",
      " |  \n",
      " |  setNumberOfSamples(...)\n",
      " |      setNumberOfSamples(self: pytchem.TChemDriver, number_of_samples: int) -> None\n",
      " |      \n",
      " |      Set the number of samples; this is used for Kokkos view allocation\n",
      " |  \n",
      " |  setStateVector(...)\n",
      " |      setStateVector(*args, **kwargs)\n",
      " |      Overloaded function.\n",
      " |      \n",
      " |      1. setStateVector(self: pytchem.TChemDriver, sample_index: int, 1d_state_vector: numpy.ndarray[numpy.float64]) -> None\n",
      " |      \n",
      " |      Overwrite state vector for a single sample\n",
      " |      \n",
      " |      2. setStateVector(self: pytchem.TChemDriver, 2d_state_vector: numpy.ndarray[numpy.float64]) -> None\n",
      " |      \n",
      " |      Overwrite state vector for all samples\n",
      " |  \n",
      " |  setTimeAdvanceHomogeneousGasReactor(...)\n",
      " |      setTimeAdvanceHomogeneousGasReactor(self: pytchem.TChemDriver, tbeg: float, tend: float, dtmin: float, dtmax: float, jacobian_interval: int, max_num_newton_iterations: int, num_time_iterations_per_interval: int, atol_newton: float, rtol_newton: float, atol_time: float, rtol_time: float) -> None\n",
      " |      \n",
      " |      Set time advance object for homogeneous gas reactor\n",
      " |  \n",
      " |  showViewStatus(...)\n",
      " |      showViewStatus(self: pytchem.TChemDriver) -> None\n",
      " |      \n",
      " |      Print member variable view status\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from pybind11_builtins.pybind11_object:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from pybind11_builtins.pybind11_type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(tchem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Kinetic Model \n",
    "\n",
    "* Inputs are the reactions mechanism files; in this case, we use the GRI3.0 gas reaction mechanism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs_directory = TChem_install_directory + '/example/data/ignition-zero-d/gri3.0/'\n",
    "tchem.createGasKineticModel(inputs_directory+'chem.inp',inputs_directory+'therm.dat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Set number of samples \n",
    "* Internally construct const object of the kinetic model and load them to device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tchem.setNumberOfSamples(N)\n",
    "tchem.createGasKineticModelConstData()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set State Vector\n",
    "\n",
    "* Get index for variables. \n",
    "* Pass a numpy array to the TChem object to set the state vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Variables = ['T','P','CH4','O2','N2','AR']\n",
    "indx=[]\n",
    "for var in Variables:\n",
    "    indx += [tchem.getStateVariableIndex(var)]\n",
    "\n",
    "state = np.zeros([N, tchem.getLengthOfStateVector()])\n",
    "for sp in range(N):\n",
    "    state[sp,indx] = sample[sp,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "tchem.createStateVector()\n",
    "tchem.setStateVector(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Time Integrator and Its Parameters \n",
    "* Kokkos team policy is constructed for parallel execution\n",
    "* Workspace per team is also allocated with the teampolicy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tend = 2.2\n",
    "tchem.setTimeAdvanceHomogeneousGasReactor(tbeg=0, \n",
    "                     tend=tend, \n",
    "                     dtmin=1e-10,\n",
    "                     dtmax=1e-3, \n",
    "                     atol_time=1e-12,\n",
    "                     rtol_time=1e-6,\n",
    "                     max_num_newton_iterations=20,\n",
    "                     atol_newton=1e-18,\n",
    "                     rtol_newton=1e-8,\n",
    "                     num_time_iterations_per_interval=20,\n",
    "                     jacobian_interval=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Advance simulations: for each iteration, get state vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count  50 simulation time  4.990e-01 s, total time  2.200e+00 s\n",
      "count 100 simulation time  1.428e+00 s, total time  2.200e+00 s\n",
      "Wall time is 6.3188 mins for time integration\n"
     ]
    }
   ],
   "source": [
    "solution = []\n",
    "time_simulation = []\n",
    "\n",
    "tavg = 0\n",
    "t0 = time.time()\n",
    "icount = 0\n",
    "while (tavg < tend*0.999):\n",
    "    tavg = tchem.computeTimeAdvanceHomogeneousGasReactor()\n",
    "    solution += [tchem.getStateVector()]\n",
    "    time_simulation += [tchem.getTimeStep()]\n",
    "    icount +=1\n",
    "    if (icount%50 == 0):\n",
    "        print(f\"count {icount:3d} simulation time {tavg:10.3e} s, total time {tend:10.3e} s\")\n",
    "\n",
    "t1 = time.time()\n",
    "\n",
    "print(f\"Wall time is {(t1 - t0)/60:0.4f} mins for time integration\")\n",
    "\n",
    "solution = np.array(solution)\n",
    "time_simulation = np.array(time_simulation) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Post-processing\n",
    "* Get variable index for plotting. \n",
    "* Compute the ignition delay time with data produced by the simulation.\n",
    "* Plot time profiles for important variables and for the ignition delay time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "T_indx   = tchem.getStateVariableIndex('T')\n",
    "CH4_indx = tchem.getStateVariableIndex('CH4')\n",
    "O2_indx  = tchem.getStateVariableIndex('O2')\n",
    "CO_indx  = tchem.getStateVariableIndex('CO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "T_threshold=1500\n",
    "def computeIgnitionDelayTime(T_threshold=1500):\n",
    "    ntimes, nsamples, nVars = np.shape(solution)\n",
    "    ignDelayTime = []\n",
    "    for isample in range(nsamples):\n",
    "        Indx = np.where(solution[:,isample,T_indx] >= T_threshold )\n",
    "        ignDelayTime += [time_simulation[Indx[0][0],isample] ] \n",
    "    return np.array(ignDelayTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "IgnTime = computeIgnitionDelayTime()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "info={}\n",
    "info['label1'] = {'label':'Temperature','units':' [K]'}\n",
    "info['label2'] = {'label': 'CH4','units':' Mass Fraction'}\n",
    "info['label3'] = {'label': 'O2','units':'  Mass Fraction'}\n",
    "info['label4'] = {'label': 'CO','units':'  Mass Fraction'}\n",
    "info['loc_x'] = 0.45\n",
    "info['loc_y'] = 0.75\n",
    "info['xlim'] = [0,1]\n",
    "\n",
    "info['inset_x1'] = 0.55 + 0.5 \n",
    "info['inset_y1'] = 0.4\n",
    "info['inset_x2'] = 0.3 \n",
    "info['inset_y2'] = 0.4\n",
    "\n",
    "spNumber = 0\n",
    "info['xlim2'] = [IgnTime[spNumber]*0.95,IgnTime[spNumber]*1.05]\n",
    "info['xlim'] = [0,time_simulation[-1,spNumber]]\n",
    "\n",
    "plt.figure()\n",
    "x  = time_simulation[:,spNumber]\n",
    "y1 = solution[:,spNumber, T_indx]\n",
    "y2 = solution[:,spNumber, CH4_indx]\n",
    "y3 = solution[:,spNumber, O2_indx]\n",
    "y4 = solution[:,spNumber, CO_indx]\n",
    "helper.makefigure(x, y1, y2, y3, y4, info, fs_label=16, fs_tick=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dirOutput = ''\n",
    "Np = np.where(IgnTime>0)[0]\n",
    "x = 1000./sample[Np,0]\n",
    "Yo2 = sample[Np,3]\n",
    "z = IgnTime[Np]\n",
    "name_value =  'Ignition delay time [s] at P=1atm'\n",
    "helper.plotResults(x, phi[Np], z,name_value, y_label_name='Equivalence ratio ($\\phi$)',\n",
    "            xtickvalues=[0.8, 0.85, 0.9, 0.95, 1],ytickvalues=[1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalize Kokkos. This deletes the TChem object and the data stored as Kokkos views"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(tchem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "pytchem.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
